package com.chenwc.netty.tcp.client;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.UUID;

import com.chenwc.netty.tcp.coder.Message;
import com.chenwc.netty.tcp.config.NettyProperties;
import com.chenwc.netty.tcp.enums.MessageEnum;
import com.google.common.primitives.Bytes;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSONObject;

/**
 * tcp客户端
 * 传统的TCP连接是短连接，即在通信完成后立即断开连接。
 * @author CalvinChan
 */
public class ShortConnectionClient {

    private static final Logger log = LoggerFactory.getLogger(ShortConnectionClient.class);

    public static void main(String[] args) {
        // TODO 自动生成的方法存根

        log.info("-------------客户端------------");

        NettyProperties nettyProperties = new NettyProperties();

        Socket client = null;
        // 得到网络输入输出流
        PrintWriter out = null;
        InputStream is = null;
        //用户获取控制台输入
        Scanner sc = new Scanner(System.in);
        //客户端ID
        String ep_id = UUID.randomUUID().toString().replace("-", "");
        try {
            //客户端
            client = new Socket(InetAddress.getByName("localhost"), 9877);
            //输入流
            is = client.getInputStream();
            //输出流
            out = new PrintWriter(new OutputStreamWriter(client.getOutputStream(), StandardCharsets.UTF_8));

            JSONObject body = new JSONObject();
            body.put("ep_id", ep_id);
            String content = "";

            //content = sc.nextLine();
            content = "啦啦啦啦啦";
            body.put("time", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
            body.put("content", content);
            //生成消息实例
            Message message = new Message(body.toJSONString(), MessageEnum.CONNECT);
            log.info("发送的消息：{}", message.toJsonString());
            //发送消息时必须加上数据分割符
            out.println(message.toJsonString() + nettyProperties.getDelimiterStr());
            // 刷新不能缺少，缓冲区数据强制输出
            out.flush();
            //通过shutdownOutput告诉服务器已经发送完数据，后续只能接受数据
            client.shutdownOutput();

            // 得到服务器端传来的信息
            String strtmp = "";
            int size = 0;
            while (size == 0) {
                size = is.available();
            }
			/*
				如果使用 BufferedReader 读取数据，读入的数据要必须要有/r或/n或/r/n，没有数据时会阻塞
				在数据流异常或断开时会返回 null，如果发送方发送的数据没在末尾加/r或/n或/r/n，就会返回 0 字节，然后出现异常。
			 */
            if (size > 0) {
                byte[] tp = new byte[1];
                List<Byte> list = new ArrayList<>();
                while (is.read(tp) > 0) {
                    list.add(tp[0]);
                }
                strtmp = new String(listByteToByte(list), StandardCharsets.UTF_8);
            }
            if (StringUtils.isNotEmpty(strtmp)) {
                String[] ret = strtmp.split(nettyProperties.getDelimiterStr());
                JSONObject retBody = JSONObject.parseObject(ret[0]).getJSONObject("body");
                log.info("服务端响应：{}", retBody.toJSONString());
            }

        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        } finally {
            try {
                sc.close();
                IOUtils.closeQuietly(is);
                IOUtils.closeQuietly(out);
                if (null != client) {
                    client.close();
                }
            } catch (Exception e2) {
                // TODO: handle exception
                e2.printStackTrace();
            }

        }
    }

    /**
     * List<Byte> 转 byte[]
     *
     * @param list List<Byte>
     * @return byte[]
     */
    public static byte[] listByteToByte(List<Byte> list) {
        if (list == null)
            return null;
        return Bytes.toArray(list);
    }
}
